#pragma once

#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <mutex>
#include <memory>
#include <stack>
#include <chrono>
#include <algorithm>

namespace viml {

// 前向声明，避免包含冲突
class Object;
class Value;
class StringObject;
class ListObject;
class DictObject;
class Closure;

/**
 * 垃圾回收器根集
 * 用于标记-清除算法的根对象收集
 * 优化版本：支持去重、批量操作和统计信息
 */
class GCRootSet {
public:
    // 根对象类型分类
    enum class RootType {
        STACK,          // 栈对象
        GLOBAL,         // 全局对象
        REGISTER,       // 寄存器对象
        INTERNAL,       // 内部对象
        USER            // 用户对象
    };

    // 根集统计信息
    struct Stats {
        size_t total_roots = 0;
        size_t unique_objects = 0;
        size_t stack_roots = 0;
        size_t global_roots = 0;
        size_t register_roots = 0;
        size_t internal_roots = 0;
        size_t user_roots = 0;
        size_t duplicate_removals = 0;
        size_t batch_operations = 0;
        double avg_add_time_us = 0.0;
    };

private:
    // 使用unordered_set进行去重，vector用于遍历
    std::unordered_set<Object*> root_set_;
    mutable std::vector<Object*> root_list_;  // 用于遍历的有序列表
    std::unordered_map<Object*, RootType> root_types_;

    // 缓存标记，用于优化
    mutable bool list_dirty_ = true;  // 标记列表是否需要更新
    bool locked_ = false;

    // 统计信息
    Stats stats_;
    mutable std::mutex stats_mutex_;

    // 内部辅助方法
    void update_root_list() const;
    void update_stats(Object* obj, RootType type, bool added);
    bool extract_objects_from_value(const Value& value, std::vector<Object*>& objects) const;

public:
    GCRootSet() = default;
    ~GCRootSet() = default;

    // 基本添加/删除操作
    void add_root(Object* obj);
    void add_root(Object* obj, RootType type);
    bool remove_root(Object* obj);

    // 值对象处理（完整实现）
    void add_value_root(const Value& value);
    void add_value_root(const Value& value, RootType type);
    bool remove_value_root(const Value& value);

    // 批量操作
    void add_roots(const std::vector<Object*>& objects);
    void add_roots(const std::vector<Object*>& objects, RootType type);
    void add_value_roots(const std::vector<Value>& values);
    void add_value_roots(const std::vector<Value>& values, RootType type);

    // 清空操作
    void clear_roots();
    void clear_roots(RootType type);  // 清除特定类型的根对象

    // 查询操作
    size_t size() const;
    size_t unique_size() const;
    bool contains(Object* obj) const;
    size_t count_type(RootType type) const;

    // 遍历操作（优化版本）
    const std::vector<Object*>& get_roots() const;
    std::vector<Object*> get_roots(RootType type) const;

    // 类型操作
    RootType get_root_type(Object* obj) const;
    bool set_root_type(Object* obj, RootType type);

    // 统计信息
    Stats get_stats() const;
    void reset_stats();

    // 线程安全
    void lock();
    void unlock();
    bool is_locked() const { return locked_; }

    // 调试和诊断
    void print_stats() const;
    void validate_integrity() const;
};

/**
 * 垃圾回收器
 * 实现分代垃圾回收算法
 */
class GarbageCollector {
public:
    // 回收结果统计
    struct CollectionResult {
        size_t objects_collected = 0;
        size_t bytes_collected = 0;
        double collection_time_ms = 0.0;
        size_t young_gen_collected = 0;
        size_t old_gen_collected = 0;
        size_t gen_0_collected = 0;
        size_t gen_1_collected = 0;
        size_t gen_2_collected = 0;
        // 更多分代统计...
    };

private:
    // 分代配置
    struct GenerationConfig {
        size_t capacity;
        size_t promotion_age;
        size_t max_objects;
    };

    // 分代定义
    enum class Generation {
        YOUNG,    // 年轻代（新对象）
        OLD_0,     // 老年代0（中等年龄对象）
        OLD_1,     // 老年代1（高龄对象）
        OLD_2,     // 老年代2（最老对象）
        GENERATION_COUNT
    };

    static constexpr size_t GENERATION_COUNT = static_cast<size_t>(Generation::GENERATION_COUNT);
    static constexpr size_t SURVIVAL_THRESHOLD = 2;   // 对象需要存活多少次才考虑晋升

    // 对象存储
    std::vector<std::unique_ptr<Object>> generations_[GENERATION_COUNT];
    std::unordered_set<Object*> generation_objects_[GENERATION_COUNT];

    // 分代配置
    GenerationConfig configs_[GENERATION_COUNT];

    // 垃圾回收状态
    bool is_collecting_ = false;
    bool is_enabled_ = true;
    GCRootSet* root_set_ = nullptr;

    mutable std::mutex gc_mutex_;

public:
    // 增量收集状态
    enum class IncrementalPhase {
        IDLE,           // 空闲状态
        MARK_ROOTS,     // 标记根对象
        MARK_WORKLIST,  // 处理标记工作列表
        SWEEP_PREPARE,  // 准备清除
        SWEEP_OBJECTS,  // 清除对象
        FINALIZE        // 完成回收
    };

    explicit GarbageCollector();
    ~GarbageCollector() = default;

    // 设置根集
    void set_root_set(GCRootSet* root_set);

    // 添加对象到垃圾回收管理
    void add_object(Object* obj);

    // 手动触发垃圾回收
    CollectionResult collect();

    // 增量垃圾回收
    CollectionResult incremental_collect();
    bool needs_incremental_collection() const;
    IncrementalPhase get_incremental_phase() const { return incremental_phase_; }

    // 获取统计信息
    struct Stats {
        size_t total_objects = 0;
        size_t young_gen_objects = 0;
        size_t old_gen_0_objects = 0;
        size_t old_gen_1_objects = 0;
        size_t old_gen_2_objects = 0;
        size_t total_bytes_allocated = 0;
        size_t total_bytes_freed = 0;
        size_t total_collections = 0;
        double average_collection_time_ms = 0.0;
        double collection_frequency = 0.0;

        // 增量收集统计
        size_t incremental_collections = 0;
        double incremental_time_ms = 0.0;
        size_t incremental_marked_objects = 0;
        size_t incremental_swept_objects = 0;
        double incremental_efficiency = 0.0; // 效率：每毫秒处理的对象数
    };

    Stats get_stats() const;

    // 重置统计信息
    void reset_stats();

    // 启用/禁用垃圾回收
    void set_enabled(bool enabled);
    bool is_enabled() const;

private:
    // 增量收集状态
    IncrementalPhase incremental_phase_;
    std::vector<Object*> mark_worklist_;  // 标记工作列表
    std::vector<Object*> sweep_candidates_; // 待清除对象列表
    size_t current_mark_index_ = 0;       // 当前标记索引
    size_t current_sweep_index_ = 0;      // 当前清除索引
    static constexpr size_t INCREMENTAL_WORK_QUANTUM = 50; // 每次增量处理的对象数量
    static constexpr double MAX_INCREMENTAL_TIME_MS = 5.0; // 最大增量时间

    // 统计信息
    size_t total_allocations_ = 0;
    size_t total_collections_ = 0;
    size_t collection_count_ = 0;
    std::chrono::high_resolution_clock::time_point last_collection_time_;
    double total_collection_time_ms_ = 0.0;

    // 增量收集统计
    size_t incremental_collections_ = 0;
    double incremental_time_ms_ = 0.0;
    size_t incremental_marked_objects_ = 0;
    size_t incremental_swept_objects_ = 0;

    // 标记阶段
    void mark_phase();

    // 递归标记对象
    void mark_object(Object* obj);
    void mark_value(const Value& value);
    void mark_closure(const Closure* closure);

    // 增量收集私有方法
    void start_incremental_collection();
    CollectionResult incremental_step();
    void incremental_mark_roots_phase();
    void incremental_mark_worklist_phase();
    void incremental_sweep_prepare_phase();
    void incremental_sweep_objects_phase();
    void finalize_incremental_collection();
    void push_to_mark_worklist(Object* obj);
    bool should_continue_incremental_step(const std::chrono::high_resolution_clock::time_point& start_time) const;

    // 清除阶段
    void sweep_phase();

    // 对象管理和晋升
    Generation get_object_generation(Object* obj) const;
    void promote_object(Object* obj, Generation new_generation);
    void move_to_generation(Object* obj, Generation from_gen, Generation to_gen);
    void remove_from_generation(Object* obj, Generation from_gen);

    // 分代管理
    void cleanup_generation(Generation gen);
    void balance_generations();
    void perform_promotions();
    double estimate_average_object_size() const;

    // 对象生命周期管理
    void finalize_object(Object* obj);
    size_t get_object_size(Object* obj) const;

    // 工具方法
    Generation char_to_generation(char gen) const;
    const char* generation_to_char(Generation gen) const;
    void print_generation_stats() const;

    // 线程安全
    void lock_gc();
    void unlock_gc();
};

/**
 * 垃圾回收器工厂
 * 创建和管理垃圾回收器实例
 */
class GCManager {
private:
    static std::unique_ptr<GarbageCollector> instance_;
    static std::mutex instance_mutex_;
    static GCRootSet* global_root_set_;

public:
    // 获取全局垃圾回收器实例
    static GarbageCollector& get_instance();

    // 设置全局根集
    static void set_global_root_set(GCRootSet* root_set);

    // 手动触发全局垃圾回收
    static GarbageCollector::CollectionResult collect_garbage();

    // 增量垃圾回收
    static GarbageCollector::CollectionResult incremental_collect();
    static bool needs_incremental_collection();
    static GarbageCollector::IncrementalPhase get_incremental_phase();

    // 获取全局统计信息
    static GarbageCollector::Stats get_global_stats();

    // 重置全局统计
    static void reset_global_stats();

    // 禁用垃圾回收（用于测试）
    static void disable();
    static void enable();
};

} // namespace viml